package com.zhoug.player3.exo;

import android.util.Log;

import com.zhoug.common3.BuildConfig;

import androidx.annotation.Nullable;
import androidx.media3.common.AudioAttributes;
import androidx.media3.common.DeviceInfo;
import androidx.media3.common.MediaItem;
import androidx.media3.common.MediaMetadata;
import androidx.media3.common.PlaybackException;
import androidx.media3.common.PlaybackParameters;
import androidx.media3.common.Player;
import androidx.media3.common.Timeline;
import androidx.media3.common.TrackSelectionParameters;
import androidx.media3.common.Tracks;
import androidx.media3.common.VideoSize;
import androidx.media3.common.text.CueGroup;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.exoplayer.ExoPlayer;

/**
 * Player.Listener的包装类
 * user {@link ExoPlayer#addListener(Player.Listener)}
 *
 * @Author: zhoug
 * @Date: 2023/1/6
 * @Description:
 */
@UnstableApi
class ExoPlayerListenerWrapper implements Player.Listener {
    private static final String TAG = ">>>ExoPlayerListener";
    private static boolean DEBUG = BuildConfig.DEBUG;

    /**
     * 当一个或多个Player状态更改时调用
     *
     * @param player
     * @param events
     */
    @Override
    public void onEvents(Player player, Player.Events events) {
        /*if (DEBUG) {
            if (events != null && events.size() > 0) {
                for (int i = 0; i < events.size(); i++) {
                    int event = events.get(i);
                    Log.d(TAG, "onEvents:" + event);
                }
            }
        }*/
    }

    /**
     * 当播放器开始或停止加载源时调用
     *
     * @param isLoading
     */
    @Override
    public void onIsLoadingChanged(boolean isLoading) {
        if (DEBUG) {
            Log.d(TAG, String.format("onIsLoadingChanged:播放器%s加载资源", isLoading ? "开始" : "停止"));
            //"onIsLoadingChanged:播放器开始或停止加载源,isLoading=" + isLoading);
        }
    }


    /**
     * getPlaybackState()播放状态改变时调用
     *
     * @param playbackState
     */
    @Override
    public void onPlaybackStateChanged(int playbackState) {
        if (DEBUG) {
            String statusName="";
            switch (playbackState){
                case Player.STATE_IDLE:
                    statusName="空闲";
                    break;
                case Player.STATE_BUFFERING:
                    statusName="缓冲";
                    break;
                case Player.STATE_READY:
                    statusName="准备好了,getPlayWhenReady()==true时会立即播放否则暂停";
                    break;
                case Player.STATE_ENDED:
                    statusName="播放完成";
                    break;
            }
            Log.d(TAG, "onPlaybackStateChanged:" + statusName);
        }
    }

    /**
     * getPlayWhenReady() 播放/暂停改变时调用
     *
     * @param playWhenReady
     * @param reason
     */
    @Override
    public void onPlayWhenReadyChanged(boolean playWhenReady, int reason) {
        if (DEBUG) {
            Log.d(TAG, "onPlayWhenReadyChanged:播放/暂停改变,playWhenReady=" + playWhenReady);
        }
    }

    /**
     * isPlaying() 改变调用
     *
     * @param isPlaying
     */
    @Override
    public void onIsPlayingChanged(boolean isPlaying) {
        if (DEBUG) {
            Log.d(TAG, "onIsPlayingChanged:isPlaying改变,isPlaying=" + isPlaying);
        }
    }

    /**
     * 播放错误时调用,状态置为:STATE_IDLE
     *
     * @param error
     */
    @Override
    public void onPlayerError(PlaybackException error) {
        Log.e(TAG, "onPlayerError:播放错误,errorCode=" + error.errorCode + ",errorCodeName=" + error.getErrorCodeName() + ",message" + error.getMessage());
    }

    /**
     * 刷新时间线时调用
     * {@link Player#EVENT_TIMELINE_CHANGED}
     *
     * @param timeline
     * @param reason
     */
    @Override
    public void onTimelineChanged(Timeline timeline, int reason) {
//        if (DEBUG) {
//            Log.d(TAG, "onTimelineChanged:刷新时间线"
//                    + ",firstWindowIndex:" + timeline.getFirstWindowIndex(true)
//                    + ",lastWindowIndex:" + timeline.getLastWindowIndex(true)
//                    + ",periodCount:" + timeline.getPeriodCount()
//                    + ",windowCount:" + timeline.getWindowCount()
//            );
//
//        }
    }

    /**
     * 当轨迹改变时调用
     *
     * @param tracks
     */
    @Override
    public void onTracksChanged(Tracks tracks) {
        /*if (DEBUG) {
            Log.d(TAG, "onTracksChanged:轨迹改变," + tracks.toBundle());
        }*/
    }

    /**
     * 当播放转换到另一个媒体项目，或开始重复同一媒体项目时调用
     *
     * @param mediaItem
     * @param reason
     */
    @Override
    public void onMediaItemTransition(@Nullable MediaItem mediaItem, int reason) {
        if (DEBUG) {
            Log.d(TAG, "onMediaItemTransition:" + (mediaItem != null ? mediaItem.mediaMetadata : null));
        }
    }

    /**
     * 当组合的｛@link MediaMetadata｝更改时调用。
     *
     * @param mediaMetadata
     */
    @Override
    public void onMediaMetadataChanged(MediaMetadata mediaMetadata) {
        if (DEBUG) {
            Log.d(TAG, "onMediaMetadataChanged:MediaMetadata更改," + mediaMetadata);
        }
    }

    /**
     * 当播放列表｛@link MediaMetadata｝更改时调用
     *
     * @param mediaMetadata
     */
    @Override
    public void onPlaylistMetadataChanged(MediaMetadata mediaMetadata) {
        if (DEBUG) {
            Log.d(TAG, "onPlaylistMetadataChanged:播放列表MediaMetadata更改," + mediaMetadata);
        }
    }

    /**
     * 当从｛@link#isCommandAvailable（int）｝返回的值至少为一个｛@link Command｝更改时调用
     *
     * @param availableCommands
     */
    @Override
    public void onAvailableCommandsChanged(Player.Commands availableCommands) {
        if (DEBUG) {
            Log.d(TAG, "onAvailableCommandsChanged:" + availableCommands);
        }
    }

    /**
     * 当从｛@link#getTrackSelectionParameters（）｝返回的值更改时调用。
     *
     * @param parameters
     */
    @Override
    public void onTrackSelectionParametersChanged(TrackSelectionParameters parameters) {
        if (DEBUG) {
            Log.d(TAG, "onTrackSelectionParametersChanged:" + parameters.toBundle());
        }
    }

    /**
     * 当从｛@link#getPlaybackSuppressionReason（）｝返回的值更改时调用
     *
     * @param playbackSuppressionReason
     */
    @Override
    public void onPlaybackSuppressionReasonChanged(int playbackSuppressionReason) {
        if (DEBUG) {
            Log.d(TAG, "onPlaybackSuppressionReasonChanged:" + playbackSuppressionReason);
        }
    }

    /**
     * 当｛@link#getRepeatMode（）｝的值更改时调用
     *
     * @param repeatMode
     */
    @Override
    public void onRepeatModeChanged(int repeatMode) {
        if (DEBUG) {
            Log.d(TAG, "onRepeatModeChanged:重复模式更改,repeatMode=" + repeatMode);
        }
    }

    /**
     * 当｛@link#getShuffleModeEnabled（）｝的值更改时调用。
     *
     * @param shuffleModeEnabled
     */
    @Override
    public void onShuffleModeEnabledChanged(boolean shuffleModeEnabled) {
        if (DEBUG) {
            Log.d(TAG, "onShuffleModeEnabledChanged:" + shuffleModeEnabled);
        }
    }

    /**
     * 当｛@link#getPlayerError（）｝返回的｛@link PlaybackException｝更改时调用
     *
     * @param error
     */
    @Override
    public void onPlayerErrorChanged(@Nullable PlaybackException error) {
        if (DEBUG) {
            Log.d(TAG, "onPlayerErrorChanged:" + error);
        }
    }

    /**
     * 发生位置不连续时调用
     *
     * @param oldPosition
     * @param newPosition
     * @param reason
     */
    @Override
    public void onPositionDiscontinuity(Player.PositionInfo oldPosition, Player.PositionInfo newPosition, int reason) {
        if (DEBUG) {
            Log.d(TAG, "onPositionDiscontinuity: 发生位置不连续," + oldPosition + "->" + newPosition);
        }
    }

    /**
     * 当当前播放参数更改时调用
     *
     * @param playbackParameters
     */
    @Override
    public void onPlaybackParametersChanged(PlaybackParameters playbackParameters) {
        if (DEBUG) {
            Log.d(TAG, "onPlaybackParametersChanged:前播放参数更改," + playbackParameters);
        }
    }

    /**
     * 当｛@link#getSeekBackIncrement（）｝的值更改时调用。
     *
     * @param seekBackIncrementMs
     */
    @Override
    public void onSeekBackIncrementChanged(long seekBackIncrementMs) {
        if (DEBUG) {
            Log.d(TAG, "onSeekBackIncrementChanged:" + seekBackIncrementMs);
        }
    }

    /**
     * 当｛@link#getSeekForwardIncrement（）｝的值更改时调用
     *
     * @param seekForwardIncrementMs
     */
    @Override
    public void onSeekForwardIncrementChanged(long seekForwardIncrementMs) {
        if (DEBUG) {
            Log.d(TAG, "onSeekForwardIncrementChanged:" + seekForwardIncrementMs);
        }
    }

    /**
     * 当｛@link#getMaxSeekToPreviousPosition（）｝的值更改时调用
     *
     * @param maxSeekToPreviousPositionMs
     */
    @Override
    public void onMaxSeekToPreviousPositionChanged(long maxSeekToPreviousPositionMs) {
        if (DEBUG) {
            Log.d(TAG, "onMaxSeekToPreviousPositionChanged:" + maxSeekToPreviousPositionMs);
        }
    }



    /**
     * 当音频属性更改时调用
     *
     * @param audioAttributes
     */
    @Override
    public void onAudioAttributesChanged(AudioAttributes audioAttributes) {
        if (DEBUG) {
            Log.d(TAG, "onAudioAttributesChanged:音频属性更改," + audioAttributes);
        }
    }

    /**
     * 当音量改变时调用
     *
     * @param volume
     */
    @Override
    public void onVolumeChanged(float volume) {
        if (DEBUG) {
            Log.d(TAG, "onVolumeChanged:音量改变,volume=" + volume);
        }
    }

    /**
     * 在音频流中启用或禁用跳过静音时调用
     *
     * @param skipSilenceEnabled
     */
    @Override
    public void onSkipSilenceEnabledChanged(boolean skipSilenceEnabled) {
        if (DEBUG) {
            Log.d(TAG, "onSkipSilenceEnabledChanged:音频流中启用或禁用跳过静音,skipSilenceEnabled=" + skipSilenceEnabled);
        }
    }

    /**
     * 当设备信息更改时调用
     *
     * @param deviceInfo
     */
    @Override
    public void onDeviceInfoChanged(DeviceInfo deviceInfo) {
        if (DEBUG) {
            Log.d(TAG, "onDeviceInfoChanged:设备信息更改," + deviceInfo);
        }
    }

    /**
     * 当设备音量或静音状态更改时调用。
     *
     * @param volume
     * @param muted
     */
    @Override
    public void onDeviceVolumeChanged(int volume, boolean muted) {
        if (DEBUG) {
            Log.d(TAG, "onDeviceVolumeChanged:设备音量或静音状态更改,volume=" + volume + ",muted=" + muted);
        }
    }

    /**
     * 每次渲染的视频大小发生变化时调用
     *
     * @param videoSize
     */
    @Override
    public void onVideoSizeChanged(VideoSize videoSize) {
        if (DEBUG) {
            Log.d(TAG, "onVideoSizeChanged:渲染的视频大小发生变化,width=" + videoSize.width + ",height=" + videoSize.height);
        }
    }

    /**
     * 每当视频所在Surface的大小发生变化时调用
     * <p>
     * 提供
     *
     * @param width
     * @param height
     */
    @Override
    public void onSurfaceSizeChanged(int width, int height) {
        if (DEBUG) {
            Log.d(TAG, "onSurfaceSizeChanged:视频所在Surface的大小发生变化,width=" + width + ",height=" + height);
        }
    }

    /**
     * 在设置曲面后首次渲染帧时调用，或者在重置渲染器后调用，或者当正在渲染的流更改时调用
     */
    @Override
    public void onRenderedFirstFrame() {
        if (DEBUG) {
            Log.d(TAG, "onRenderedFirstFrame:首次渲染帧");
        }
    }

    /**
     * 在｛@link CueGroup｝中发生更改时调用。
     *
     * @param cueGroup
     */
    @Override
    public void onCues(CueGroup cueGroup) {
        if (DEBUG) {
            Log.d(TAG, "onCues:" + cueGroup);
        }
    }



}
